home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / labeldisk / tmp < prev    next >
Encoding:
Text File  |  1992-09-08  |  44.1 KB  |  1,465 lines
  1. *** /tmp/,RCSt1335642    Mon Sep  7 19:41:37 1992
  2. --- labeldisk.c    Mon Sep  7 19:35:19 1992
  3. ***************
  4. *** 8,37 ****
  5.    */
  6.   
  7.   #ifndef lint
  8. ! static char rcsid[] = "$Header: /sprite/src/cmds/labeldisk/RCS/labeldisk.c,v 1.7 90/02/16 16:11:43 shirriff Exp $ SPRITE (Berkeley)";
  9.   #endif not lint
  10.   
  11. ! #include "sprite.h"
  12.   #include "option.h"
  13. ! #include "sys/file.h"
  14. ! #include "stdio.h"
  15. ! #include "errno.h"
  16. ! #include "diskUtils.h"
  17. ! #include "kernel/dev.h"
  18.   
  19.   /*
  20.    * Constants settable via the command line.
  21.    */
  22. ! char *deviceName;        /* ie. set to "/dev/rsd0" */
  23.   Boolean writeLabel = FALSE;
  24.   Boolean writeSun = FALSE;
  25.   Boolean writeDec = FALSE;
  26. - Boolean writeSprite = FALSE;
  27.   Boolean newLabel = FALSE;
  28.   
  29.   Option optionArray[] = {
  30.       {OPT_DOC,"",(Address)NIL,
  31. !     "labeldisk [-w] [-sun] [-dec] [-sprite] [-new] rawDevice"},
  32.       {OPT_TRUE, "w", (Address)&writeLabel,
  33.       "Write a new disk label"},
  34.       {OPT_TRUE, "sun", (Address)&writeSun,
  35. --- 8,41 ----
  36.    */
  37.   
  38.   #ifndef lint
  39. ! static char rcsid[] = "$Header: /sprite/src/cmds/labeldisk/RCS/labeldisk.c,v 1.15 92/02/06 12:05:21 voelker Exp Locker: voelker $ SPRITE (Berkeley)";
  40.   #endif not lint
  41.   
  42. ! #include <sprite.h>
  43.   #include "option.h"
  44. ! #include "disk.h"
  45. ! #include <sys/file.h>
  46. ! #include <stdio.h>
  47. ! #include <errno.h>
  48. ! #include <kernel/dev.h>
  49.   
  50. + #define Min(a,b) (((a) < (b)) ? (a) : (b))
  51.   /*
  52.    * Constants settable via the command line.
  53.    */
  54. ! char *fromName;         /* e.g. set to "/dev/rsd0" */
  55. ! char *toName;        /* e.g. set to "/dev/rsd0g" */
  56.   Boolean writeLabel = FALSE;
  57.   Boolean writeSun = FALSE;
  58.   Boolean writeDec = FALSE;
  59.   Boolean newLabel = FALSE;
  60. + Boolean writeQuick = FALSE;
  61.   
  62.   Option optionArray[] = {
  63.       {OPT_DOC,"",(Address)NIL,
  64. !     "labeldisk [-from fromDevice] [-w] [-q] [-sun] [-dec] [-new] toDevice"},
  65. !     {OPT_STRING, "from", (char *)&fromName,
  66. !     "Read the disk label from this partition"},
  67.       {OPT_TRUE, "w", (Address)&writeLabel,
  68.       "Write a new disk label"},
  69.       {OPT_TRUE, "sun", (Address)&writeSun,
  70. ***************
  71. *** 38,64 ****
  72.       "Write a Sun label"},
  73.       {OPT_TRUE, "dec", (Address)&writeDec,
  74.       "Write a Dec label"},
  75. -     {OPT_TRUE, "sprite", (Address)&writeSprite,
  76. -     "Write a Sprite label"},
  77.       {OPT_TRUE, "new", (Address)&newLabel,
  78.       "Ignore any old label"},
  79.   };
  80.   int numOptions = sizeof(optionArray) / sizeof(Option);
  81.   
  82. ! extern short SeeSunCheckSum();
  83. ! extern unsigned int SeeSpriteCheckSum();
  84. ! 
  85. ! void    ConvertSunToSprite();
  86. ! void    ConvertSpriteToSun();
  87. ! void    ConvertDecToSprite();
  88. ! void    ConvertSpriteToDec();
  89. ! ReturnStatus    EraseOldLabel();
  90. ! 
  91. ! #define NOLABEL -1
  92. ! #define SUNLABEL 0
  93. ! #define SPRITELABEL 1
  94. ! #define DECLABEL 2
  95. ! 
  96.   
  97.   /*
  98.    *----------------------------------------------------------------------
  99. --- 42,58 ----
  100.       "Write a Sun label"},
  101.       {OPT_TRUE, "dec", (Address)&writeDec,
  102.       "Write a Dec label"},
  103.       {OPT_TRUE, "new", (Address)&newLabel,
  104.       "Ignore any old label"},
  105. +     {OPT_TRUE, "q", (Address)&writeQuick,
  106. +     "Copy label quickly, without prompting to change the label"}
  107.   };
  108.   int numOptions = sizeof(optionArray) / sizeof(Option);
  109.   
  110. ! static ReturnStatus    LabelDisk();
  111. ! static void        EditLabel();
  112. ! static void        InputNumber();
  113. ! static int        IsYes();
  114.   
  115.   /*
  116.    *----------------------------------------------------------------------
  117. ***************
  118. *** 80,94 ****
  119.       char *argv[];
  120.   {
  121.       int openFlags;
  122. !     int streamID;
  123.   
  124.       argc = Opt_Parse(argc, argv, optionArray, numOptions);
  125.       if (argc != 2) {
  126. !     Opt_PrintUsage(argv[0], optionArray, numOptions);
  127. !     exit(FAILURE);
  128. !     }
  129. !     deviceName = argv[1];
  130. !     if (writeSun || writeSprite || writeDec) {
  131.       writeLabel = TRUE;
  132.       }
  133.       if (writeLabel) {
  134. --- 74,98 ----
  135.       char *argv[];
  136.   {
  137.       int openFlags;
  138. !     int toStreamID;
  139. !     int fromStreamID;
  140. !     int tmp;
  141.   
  142.       argc = Opt_Parse(argc, argv, optionArray, numOptions);
  143.       if (argc != 2) {
  144. !     if (argc == 1 && fromName != NULL && strlen(fromName) > 0) {
  145. !         toName = fromName;
  146. !     } else {
  147. !         Opt_PrintUsage(argv[0], optionArray, numOptions);
  148. !         exit(FAILURE);
  149. !     }
  150. !     } else {
  151. !     if (fromName == NULL || strlen(fromName) == 0) {
  152. !         fromName = argv[1];
  153. !     }
  154. !     toName = argv[1];
  155. !     } 
  156. !     if (writeSun || writeDec || writeQuick) {
  157.       writeLabel = TRUE;
  158.       }
  159.       if (writeLabel) {
  160. ***************
  161. *** 96,114 ****
  162.       } else {
  163.       openFlags = O_RDONLY;
  164.       }
  165. !     if ( (writeSun?1:0)+(writeSprite?1:0)+(writeDec?1:0) > 1) {
  166.       fprintf(stderr,
  167. !         "Can't specify more than one of -sun, -dec, -sprite.\n");
  168.       Opt_PrintUsage(argv[0], optionArray, numOptions);
  169.       exit(FAILURE);
  170.       } 
  171. !     streamID = open(deviceName, openFlags, 0);
  172. !     if (streamID < 0) {
  173.       perror("Can't open device");
  174.       exit(FAILURE);
  175.       }
  176. !     if (LabelDisk(streamID) != SUCCESS) {
  177. !     perror("labeldisk");
  178.       }
  179.       exit(errno);
  180.   }
  181. --- 100,133 ----
  182.       } else {
  183.       openFlags = O_RDONLY;
  184.       }
  185. !     if ((writeSun?1:0)+(writeDec?1:0) > 1) {
  186.       fprintf(stderr,
  187. !         "Can't specify more than one of -sun, -dec.\n");
  188.       Opt_PrintUsage(argv[0], optionArray, numOptions);
  189.       exit(FAILURE);
  190.       } 
  191. !     fromStreamID = open(fromName, openFlags, 0);
  192. !     if (fromStreamID < 0) {
  193.       perror("Can't open device");
  194.       exit(FAILURE);
  195.       }
  196. !     tmp = strcmp(fromName, toName);
  197. !     if (tmp) {
  198. !     toStreamID = open(toName, openFlags, 0);
  199. !     if (toStreamID < 0) {
  200. !         perror("Can't open device");
  201. !         exit(FAILURE);
  202. !     }
  203. !     } else {
  204. !     toStreamID = fromStreamID;
  205. !     }
  206. !     if (LabelDisk(fromStreamID, toStreamID) != SUCCESS) {
  207. !     if (errno == 0) {
  208. !         fprintf(stderr, "labeldisk: Short read, or EOF encountered ");
  209. !         fprintf(stderr, "on most likely an empty partition.\n");
  210. !     } else {
  211. !         perror("labeldisk");
  212. !     }
  213.       }
  214.       exit(errno);
  215.   }
  216. ***************
  217. *** 127,220 ****
  218.    *
  219.    *----------------------------------------------------------------------
  220.    */
  221. ! ReturnStatus
  222. ! LabelDisk(streamID)
  223. !     int streamID;            /* Handle on raw disk */
  224.   {
  225. !     Disk_Info             *diskInfoPtr;
  226. !     Sun_DiskLabel         *sunLabelPtr;
  227. !     Dec_DiskLabel         *decLabelPtr;
  228. !     Fsdm_DiskHeader        *diskHeaderPtr;
  229. !     Disk_Info            diskInfo;
  230. !     Sun_DiskLabel        sunLabel;
  231. !     Dec_DiskLabel        decLabel;
  232. !     Fsdm_DiskHeader        diskHeader;
  233.       int             n;
  234.       char             answer[80];
  235. !     int             inLabel, outLabel;
  236. !     static char    *labelName[3] = {"Sun", "Sprite", "Dec"};
  237. !     static char buffer[1024], buffer2[1024];
  238.       ReturnStatus        status;
  239. ! 
  240.   
  241.       if (writeSun) {
  242. !     outLabel = SUNLABEL;
  243.       } else if (writeDec) {
  244. !     outLabel = DECLABEL;
  245. !     } else if (writeSprite) {
  246. !     outLabel = SPRITELABEL;
  247. !     } else {
  248. !     outLabel = -1;
  249. !     }
  250. !     diskHeaderPtr = (Fsdm_DiskHeader *)buffer;
  251. !     decLabelPtr = (Dec_DiskLabel *)buffer2;
  252. !     diskInfoPtr = Disk_ReadDiskInfo(streamID, 0);
  253. !     if (!newLabel && diskInfoPtr != (Disk_Info *)0) {
  254. !     sunLabelPtr = Disk_ReadSunLabel(streamID);
  255. !     if (sunLabelPtr != (Sun_DiskLabel *)0) {
  256. !         inLabel = SUNLABEL;
  257. !     } else {
  258. !         sunLabelPtr = (Sun_DiskLabel *)buffer2;
  259. !         diskHeaderPtr = Disk_ReadDiskHeader(streamID);
  260. !         if (diskHeaderPtr != (Fsdm_DiskHeader *) 0) {
  261. !         inLabel = SPRITELABEL;
  262. !         } else {
  263. !         diskHeaderPtr = (Fsdm_DiskHeader *)buffer;
  264. !         decLabelPtr = Disk_ReadDecLabel(streamID);
  265. !         if (decLabelPtr != (Dec_DiskLabel *)0) {
  266. !             inLabel = DECLABEL;
  267. !         } else {
  268. !             fprintf(stderr, "Disk label is neither Sun nor Sprite.\n");
  269. !             return(FAILURE);
  270. !         }
  271. !         }
  272. !     }
  273.       } else {
  274. !     inLabel = NOLABEL;
  275.       if (!newLabel) {
  276.           printf("The disk does not have a label.\n");
  277.       }
  278.       if (!writeLabel) {
  279. !         return(FAILURE);
  280.       }
  281. !     if (outLabel == NOLABEL) {
  282. !         printf("You must specify the -sun, -dec, or -sprite option.\n");
  283. !         return(FAILURE);
  284. !     }
  285. !     bzero(&diskInfo, sizeof(Disk_Info));
  286. !     bzero(&sunLabel, sizeof(Sun_DiskLabel));
  287. !     bzero(&decLabel, sizeof(Dec_DiskLabel));
  288. !     bzero(&diskHeader, sizeof(Fsdm_DiskHeader)); diskInfoPtr = &diskInfo;
  289. !     if (outLabel == DECLABEL) {
  290. !         diskInfoPtr->bootSector = DEC_BOOT_SECTOR;
  291. !         diskInfoPtr->numBootSectors = DEC_LABEL_SECTOR-1;
  292. !         diskInfoPtr->summarySector = DEC_SUMMARY_SECTOR;
  293. !         diskInfoPtr->domainSector = DEC_DOMAIN_SECTOR;
  294. !     } else {
  295. !         diskInfoPtr->bootSector = 1;
  296. !         diskInfoPtr->numBootSectors = 15;
  297. !         diskInfoPtr->summarySector = 17;
  298. !         diskInfoPtr->domainSector = 18;
  299. !     }
  300. !     diskInfoPtr->numDomainSectors = FSDM_NUM_DOMAIN_SECTORS;
  301. !     sunLabelPtr = &sunLabel;
  302. !     decLabelPtr = &decLabel;
  303. !     diskHeaderPtr = &diskHeader;
  304.       }
  305. !     if (outLabel == NOLABEL) {
  306.       outLabel = inLabel;
  307.       }
  308. !     if ((inLabel != outLabel) && (inLabel != NOLABEL)) {
  309.       /*
  310.        * At this point, the output label should be an empty buffer.
  311.        * diskHeaderPointer should be a valid label or empty buffer.
  312. --- 146,197 ----
  313.    *
  314.    *----------------------------------------------------------------------
  315.    */
  316. ! static ReturnStatus
  317. ! LabelDisk(fromStreamID, toStreamID)
  318. !     int fromStreamID;            /* Handle on raw input disk */
  319. !     int toStreamID;                     /* Handle on raw output disk */
  320.   {
  321. !     Disk_Label             *diskLabelPtr;
  322.       int             n;
  323.       char             answer[80];
  324. !     Disk_NativeLabelType    inLabel, outLabel;
  325. !     static char                 buffer[1024], buffer2[1024];
  326.       ReturnStatus        status;
  327. !     Ofs_DomainHeader            *headerPtr;
  328.   
  329.       if (writeSun) {
  330. !     outLabel = DISK_SUN_LABEL;
  331.       } else if (writeDec) {
  332. !     outLabel = DISK_DEC_LABEL;
  333.       } else {
  334. !     outLabel = DISK_NO_LABEL;
  335. !     }
  336. !     diskLabelPtr = Disk_ReadLabel(fromStreamID);
  337. !     if (newLabel || diskLabelPtr == NULL) {
  338.       if (!newLabel) {
  339.           printf("The disk does not have a label.\n");
  340.       }
  341.       if (!writeLabel) {
  342. !         return FAILURE;
  343.       }
  344. !     if (outLabel == DISK_NO_LABEL) {
  345. !         printf("You must specify the -sun, or -dec option.\n");
  346. !         return FAILURE;
  347. !     }
  348. !     inLabel = DISK_NO_LABEL;
  349. !     diskLabelPtr = Disk_NewLabel(outLabel);
  350.       }
  351. !     if (diskLabelPtr != NULL) {
  352. !     inLabel = diskLabelPtr->labelType;
  353. !     }
  354. !     if (outLabel == DISK_NO_LABEL) {
  355.       outLabel = inLabel;
  356.       }
  357. !     Disk_PrintLabel(diskLabelPtr);
  358. !     if (!writeLabel) {
  359. !     return SUCCESS;
  360. !     }
  361. !     if (inLabel != outLabel) {
  362.       /*
  363.        * At this point, the output label should be an empty buffer.
  364.        * diskHeaderPointer should be a valid label or empty buffer.
  365. ***************
  366. *** 222,228 ****
  367.        */
  368.       printf(
  369.         "Do you really want to replace a %s label with a %s label? (y/n) ",
  370. !       labelName[inLabel], labelName[outLabel]);
  371.       n = scanf("%s", answer);
  372.       if (n == EOF) {
  373.           exit(1);
  374. --- 199,205 ----
  375.        */
  376.       printf(
  377.         "Do you really want to replace a %s label with a %s label? (y/n) ",
  378. !       Disk_GetLabelTypeName(inLabel), Disk_GetLabelTypeName(outLabel));
  379.       n = scanf("%s", answer);
  380.       if (n == EOF) {
  381.           exit(1);
  382. ***************
  383. *** 230,613 ****
  384.       if (strcasecmp(answer, "y")) {
  385.           exit(1);
  386.       }
  387. -     /*
  388. -      * Make input into a Sprite label.  Then change to output label.
  389. -      */
  390. -     if (inLabel == SUNLABEL) {
  391. -         ConvertSunToSprite(diskInfoPtr, sunLabelPtr, diskHeaderPtr);
  392. -     } else if (inLabel == DECLABEL) {
  393. -         ConvertDecToSprite(diskInfoPtr, decLabelPtr, diskHeaderPtr);
  394. -     }
  395. -     if (outLabel == SUNLABEL) {
  396. -         ConvertSpriteToSun(diskInfoPtr, diskHeaderPtr, sunLabelPtr);
  397. -     } else if (outLabel == DECLABEL) {
  398. -         ConvertSpriteToDec(diskInfoPtr, diskHeaderPtr, decLabelPtr);
  399. -     }
  400. -     }
  401. -     /*
  402. -      * At this point, the output label should be valid.
  403. -      */
  404. -     if (outLabel == SUNLABEL) {
  405. -     status = DoSunLabel(diskInfoPtr, streamID, sunLabelPtr);
  406. -     } else if (outLabel == DECLABEL) {
  407. -     status = DoDecLabel(diskInfoPtr, streamID, decLabelPtr);
  408. -     } else {
  409. -     status = DoSpriteLabel(diskInfoPtr, streamID, diskHeaderPtr);
  410. -     }
  411. -     if (status == SUCCESS && inLabel != NOLABEL) {
  412. -     int oldsector, newsector;
  413. -     oldsector = inLabel == DECLABEL ? DEC_LABEL_SECTOR : 0;
  414. -     newsector = outLabel == DECLABEL ? DEC_LABEL_SECTOR : 0;
  415. -     if (oldsector != newsector) {
  416. -         status = EraseOldLabel(streamID, oldsector);
  417. -     }
  418.       }
  419. !     return status;
  420. ! }
  421. ! 
  422. ! 
  423. ! /*
  424. !  *----------------------------------------------------------------------
  425. !  *
  426. !  * DoSunLabel --
  427. !  *
  428. !  *    Sets up a Sun label.
  429. !  *
  430. !  * Results:
  431. !  *    None.
  432. !  *
  433. !  * Side effects:
  434. !  *    None.
  435. !  *
  436. !  *----------------------------------------------------------------------
  437. !  */
  438. ! 
  439. ! ReturnStatus
  440. ! DoSunLabel(diskInfoPtr, streamID, sunLabelPtr)
  441. !     Disk_Info            *diskInfoPtr;
  442. !     int                streamID;
  443. !     Sun_DiskLabel         *sunLabelPtr;
  444. ! {
  445. !     int             part;
  446. !     ReturnStatus         status = SUCCESS;
  447. !     int                cyls;
  448. !     int                first;
  449. !     int                last;
  450. !     Fsdm_DiskPartition        partitionMap[SUN_NUM_DISK_PARTS];
  451. ! 
  452. !     printInfo("SUN", diskInfoPtr);
  453. ! 
  454. !     /*
  455. !      * Verify the magic number and the checksum.
  456. !      */
  457. !     if (sunLabelPtr->magic != SUN_DISK_MAGIC) {
  458. !     printf("Bad magic number on disk <%x> not <%x>\n",
  459. !         sunLabelPtr->magic, SUN_DISK_MAGIC);
  460. !     }
  461. !     if (!CheckSunCheckSum(sunLabelPtr)) {
  462. !     printf("Check sum incorrect, 0x%x not 0x%x\n",
  463. !         SeeSunCheckSum(sunLabelPtr), sunLabelPtr->checkSum);
  464. !     }
  465. !     for (part=0 ; part < SUN_NUM_DISK_PARTS; part++) {
  466. !     first = sunLabelPtr->map[part].cylinder;
  467. !     if (diskInfoPtr->numHeads * diskInfoPtr->numSectors <= 0) {
  468. !         printf("%c: Cylinder %6d NumSectors %6d\n",
  469. !         first, sunLabelPtr->map[part].numBlocks);
  470. !         cyls = 0;
  471. !     } else {
  472. !         cyls = sunLabelPtr->map[part].numBlocks /
  473. !             (diskInfoPtr->numHeads * diskInfoPtr->numSectors);
  474. !         last = (cyls > 0) ? (cyls + first - 1) : first;
  475. !         printf("%c: First %4d Last %4d Num %4d (Blocks %7d)\n",
  476. !             'a' + part, first, last, cyls,
  477. !             sunLabelPtr->map[part].numBlocks);
  478.       }
  479. -     partitionMap[part].firstCylinder = first;
  480. -     partitionMap[part].numCylinders = cyls;
  481. -     }
  482. -     if (!writeLabel) {
  483. -     return(SUCCESS);
  484. -     }
  485. -     DoNewLabel(diskInfoPtr,partitionMap,SUN_NUM_DISK_PARTS, streamID);
  486. -     strcpy(sunLabelPtr->asciiLabel, diskInfoPtr->asciiLabel);
  487. -     sunLabelPtr->numHeads = diskInfoPtr->numHeads;
  488. -     sunLabelPtr->numSectors = diskInfoPtr->numSectors;
  489. -     for (part=0 ; part < SUN_NUM_DISK_PARTS; part++) {
  490. -     sunLabelPtr->map[part].cylinder = partitionMap[part].firstCylinder;
  491. -     sunLabelPtr->map[part].numBlocks = partitionMap[part].numCylinders *
  492. -            diskInfoPtr->numHeads * diskInfoPtr->numSectors;
  493. -     }
  494. -     sunLabelPtr->magic = SUN_DISK_MAGIC;
  495. -     MakeSunCheckSum(sunLabelPtr);
  496. -     printf("Writing new sun label\n");
  497. -     status = Disk_SectorWrite(streamID, 0, 1, sunLabelPtr);
  498. -     return status;
  499. - }
  500. - 
  501. - short
  502. - SeeSunCheckSum(sunLabelPtr)
  503. -     Sun_DiskLabel *sunLabelPtr;
  504. - {
  505. -         short *sp, sum = 0;
  506. -         short count = DEV_BYTES_PER_SECTOR/sizeof(short) - 1;
  507. - 
  508. -         sp = (short *)sunLabelPtr;
  509. -         while (count--)
  510. -                 sum ^= *sp++;
  511. -         return (sum);
  512. - }
  513. - 
  514. - 
  515. - CheckSunCheckSum(sunLabelPtr)
  516. -     Sun_DiskLabel *sunLabelPtr;
  517. - {
  518. -         short *sp, sum = 0;
  519. -         short count = DEV_BYTES_PER_SECTOR/sizeof(short);
  520. - 
  521. -         sp = (short *)sunLabelPtr;
  522. -         while (count--)
  523. -                 sum ^= *sp++;
  524. -         return (sum ? 0 : 1);
  525. - }
  526. - 
  527. - MakeSunCheckSum(sunLabelPtr)
  528. -     Sun_DiskLabel *sunLabelPtr;
  529. - {
  530. -         short *sp, sum = 0;
  531. -         short count = DEV_BYTES_PER_SECTOR/sizeof(short) - 1;
  532. - 
  533. -         sunLabelPtr->checkSum = 0;
  534. -         sp = (short *)sunLabelPtr;
  535. -         while (count--)
  536. -                 sum ^= *sp++;
  537. -         sunLabelPtr->checkSum = sum;
  538. - }
  539. - 
  540. - /*
  541. -  *----------------------------------------------------------------------
  542. -  *
  543. -  * DoSpriteLabel --
  544. -  *
  545. -  *    Sets up a Sprite label.
  546. -  *
  547. -  * Results:
  548. -  *    None.
  549. -  *
  550. -  * Side effects:
  551. -  *    None.
  552. -  *
  553. -  *----------------------------------------------------------------------
  554. -  */
  555. - 
  556. - ReturnStatus
  557. - DoSpriteLabel(diskInfoPtr, streamID, diskHeaderPtr)
  558. -     Disk_Info        *diskInfoPtr;
  559. -     int            streamID;
  560. -     Fsdm_DiskHeader    *diskHeaderPtr;
  561. - {
  562. -     int             part;
  563. -     int             n;
  564. -     ReturnStatus         status = SUCCESS;
  565. -     int                blocks;
  566. -     int                first;
  567. -     int                last;
  568. -     int                cyls;
  569. - 
  570. -     printInfo("SPRITE", diskInfoPtr);
  571. - 
  572. -     /*
  573. -      * Verify the magic number and the checksum.
  574. -      */
  575. -     if (diskHeaderPtr->magic != FSDM_DISK_MAGIC) {
  576. -     printf("Bad magic number on disk <%x> not <%x>\n",
  577. -         diskHeaderPtr->magic, FSDM_DISK_MAGIC);
  578. -     }
  579. -     if (!CheckSpriteCheckSum(diskHeaderPtr)) {
  580. -     printf("Check sum incorrect, 0x%x not 0x%x\n",
  581. -         SeeSpriteCheckSum(diskHeaderPtr), FSDM_DISK_MAGIC);
  582. -     }
  583. -     for (part=0 ; part < SUN_NUM_DISK_PARTS; part++) {
  584. -     first = diskHeaderPtr->map[part].firstCylinder;
  585. -     cyls = diskHeaderPtr->map[part].numCylinders;
  586. -     last = (cyls > 0) ? (cyls + first - 1) : first;
  587. -     blocks = diskInfoPtr->numHeads * diskInfoPtr->numSectors *
  588. -         diskHeaderPtr->map[part].numCylinders;
  589. -     printf("%c: First %4d Last %4d Num %4d (Blocks %7d)\n",
  590. -         'a' + part, first, last, cyls, blocks);
  591. -     }
  592. -     if (!writeLabel) {
  593. -     return(SUCCESS);
  594.       }
  595. !     DoNewLabel(diskInfoPtr,diskHeaderPtr->map,SUN_NUM_DISK_PARTS, streamID);
  596. !     diskHeaderPtr->magic = FSDM_DISK_MAGIC;
  597. !     strcpy(diskHeaderPtr->asciiLabel, diskInfoPtr->asciiLabel);
  598. !     diskHeaderPtr->numHeads = diskInfoPtr->numHeads;
  599. !     diskHeaderPtr->numSectors = diskInfoPtr->numSectors;
  600. !     diskHeaderPtr->summarySector = diskInfoPtr->summarySector;
  601. !     diskHeaderPtr->bootSector = diskInfoPtr->bootSector;
  602. !     diskHeaderPtr->numBootSectors = diskInfoPtr->numBootSectors;
  603. !     diskHeaderPtr->domainSector = diskInfoPtr->domainSector;
  604. !     MakeSpriteCheckSum(diskHeaderPtr);
  605. !     printf("Writing new sprite label\n");
  606. !     status = Disk_SectorWrite(streamID, 0, 1, diskHeaderPtr);
  607. !     {
  608. !     FILE *fopen(), *file;
  609. !     file = fopen("label.out","w");
  610. !     fwrite(diskHeaderPtr,512,1,file);
  611. !     fclose(file);
  612. !     }
  613. !     return status;
  614. ! }
  615. ! 
  616. ! unsigned int
  617. ! SeeSpriteCheckSum(diskHeaderPtr)
  618. !     Fsdm_DiskHeader *diskHeaderPtr;
  619. ! {
  620. !         int *sp, sum = 0;
  621. !     int i;
  622.   
  623. !         sp = (int *)diskHeaderPtr;
  624. !     for (i = 0; i < DEV_BYTES_PER_SECTOR; i += sizeof(int)) {
  625. !         sum ^= *sp++;
  626.       }
  627. !         return (sum);
  628. ! }
  629. ! 
  630. ! int
  631. ! CheckSpriteCheckSum(diskHeaderPtr)
  632. !     Fsdm_DiskHeader *diskHeaderPtr;
  633. ! {
  634. !         int *sp, sum = 0;
  635. !     int i;
  636. ! 
  637. !         sp = (int *)diskHeaderPtr;
  638. !     for (i = 0; i < DEV_BYTES_PER_SECTOR; i += sizeof(int)) {
  639. !         sum ^= *sp++;
  640.       }
  641. !         return (sum == FSDM_DISK_MAGIC ? 1 : 0);
  642. ! }
  643. ! 
  644. ! MakeSpriteCheckSum(diskHeaderPtr)
  645. !     Fsdm_DiskHeader *diskHeaderPtr;
  646. ! {
  647. !         int *sp, sum = 0;
  648. !     int i;
  649. ! 
  650. !     diskHeaderPtr->checkSum = FSDM_DISK_MAGIC;
  651. !         sp = (int *)diskHeaderPtr;
  652. !     for (i = 0; i < DEV_BYTES_PER_SECTOR; i += sizeof(int)) {
  653. !         sum ^= *sp++;
  654.       }
  655. !         diskHeaderPtr->checkSum = sum;
  656. ! }
  657. ! 
  658. ! /*
  659. !  *----------------------------------------------------------------------
  660. !  *
  661. !  * DoNewLabel --
  662. !  *
  663. !  *    Interactively gets the information for the new disk label.
  664. !  *
  665. !  * Results:
  666. !  *    None.
  667. !  *
  668. !  * Side effects:
  669. !  *    Changes diskInfoPtr.
  670. !  *
  671. !  *----------------------------------------------------------------------
  672. !  */
  673. !     DoNewLabel(diskInfoPtr, partitionMap, numPart, streamID)
  674. !     Disk_Info        *diskInfoPtr;
  675. !     Fsdm_DiskPartition    partitionMap[];
  676. !     int            numPart;
  677. !     int            streamID;
  678. ! {
  679. !     int n, numHeads, numSectors, part;
  680. !     char answer[80];
  681. !     ReturnStatus         status = SUCCESS;
  682. !     int first, cyls, last, numCyls, lastSector, totalSectors, lastCyl;
  683. !     char            buffer[DEV_BYTES_PER_SECTOR];
  684.   
  685.   editLabel:
  686. !     printf("ascii label: \"%s\", change this? (y/n) ", 
  687. !     diskInfoPtr->asciiLabel);
  688. !     if (isYes()) {
  689. !     char *tmpPtr;
  690. !     fgets(answer, 80, stdin);
  691. !     printf("New ascii label ? ");
  692. !     tmpPtr = fgets(diskInfoPtr->asciiLabel, 128,stdin);
  693. !     if (tmpPtr == NULL) {
  694. !         exit(1);
  695. !     }
  696. !     diskInfoPtr->asciiLabel[strlen(diskInfoPtr->asciiLabel)-1] = '\0';
  697. !     }
  698. !     numHeads = diskInfoPtr->numHeads;
  699. !     numSectors = diskInfoPtr->numSectors;
  700. !     printf("Sectors: summary %d, boot %d, # boot %d, domain %d, %s ",
  701. !         diskInfoPtr->summarySector, diskInfoPtr->bootSector,
  702. !         diskInfoPtr->numBootSectors, diskInfoPtr->domainSector,
  703. !         "change this? (y/n)");
  704. !     if (isYes()) {
  705. !     diskInfoPtr->summarySector = getNum("New summary sector?");
  706. !     diskInfoPtr->bootSector = getNum("New boot sector?");
  707. !     diskInfoPtr->numBootSectors = getNum("Number of boot sectors?");
  708. !     diskInfoPtr->domainSector = getNum("New domain sector?");
  709. !     }
  710. !     printf(" %d heads, change this? (y/n) ", numHeads);
  711. !     if (isYes()) {
  712. !     numHeads = getNum("New # of heads?");
  713. !     }
  714. !     printf(" %d sectors/track, change this (y/n) ", numSectors);
  715. !     if (isYes()) {
  716. !     numSectors = getNum("New # of sectors/track?");
  717. !     }
  718.       if (numHeads * numSectors != 
  719. !     diskInfoPtr->numHeads * diskInfoPtr->numSectors) {
  720.       printf(
  721.       "The size of a cylinder changed so I have to zero the partition map.\n");
  722. !     for (part=0 ; part < numPart; part++) {
  723. !         partitionMap[part].firstCylinder = 0;
  724. !         partitionMap[part].numCylinders = 0;
  725. !     }
  726. !     }
  727. !     diskInfoPtr->numHeads = numHeads;
  728. !     diskInfoPtr->numSectors = numSectors;
  729. !     for (part=0 ; part < numPart; part++) {
  730. !     first = partitionMap[part].firstCylinder;
  731. !     cyls = partitionMap[part].numCylinders;
  732. !     last = (cyls > 0) ? (cyls + first - 1) : first;
  733. !     printf("\n%c: First %4d Last %4d Num %4d, change this? (y/n) ",
  734. !         'a' + part, first, last, cyls);
  735. !     if (isYes()) {
  736. !         int firstCyl = -1;
  737. !         int numCyls = -1;
  738. ! 
  739. !         firstCyl = getNum("First Cyl?");
  740. !         numCyls = getNum("Num Cyls ?");
  741. !         partitionMap[part].firstCylinder = firstCyl;
  742. !         partitionMap[part].numCylinders = numCyls;
  743.       }
  744.       }
  745. !     lastCyl = 0;
  746. !     printf("\nNew Map\n");
  747. !     for (part=0 ; part < numPart; part++) {
  748. !     first = partitionMap[part].firstCylinder;
  749. !     cyls = partitionMap[part].numCylinders;
  750.       last = (cyls > 0) ? (cyls + first - 1) : first;
  751. !     if (last > lastCyl) {
  752. !         lastCyl = last;
  753. !     }
  754. !     printf("%c: First %4d Last %4d Num %4d (Cylinders %7d)\n",
  755.           'a' + part, first, last, cyls,
  756. !         partitionMap[part].numCylinders);
  757.       }
  758.       lastSector = (lastCyl + 1) * numHeads * numSectors - 1;
  759.       status = Disk_SectorRead(streamID, lastSector, 1, buffer);
  760.       if (status != 0) {
  761.       printf("I couldn't read the last sector (sector %d)!!!\n", lastSector);
  762.       }
  763.       printf("\nCommit new label? (y/n) ");
  764. !     if (!isYes()) {
  765.       printf("Try again\n");
  766.       goto editLabel;
  767.       }
  768. --- 207,418 ----
  769.       if (strcasecmp(answer, "y")) {
  770.           exit(1);
  771.       }
  772.       }
  773. !     if (!writeQuick) {
  774. !     EditLabel(toStreamID, diskLabelPtr);
  775. !     } else {
  776. !     printf("\nCommit label? (y/n) ");
  777. !     if (!IsYes()) {
  778. !         exit(0);
  779.       }
  780.       }
  781. !     if (inLabel != outLabel && fromStreamID == toStreamID) {
  782. !     status = Disk_EraseLabel(fromStreamID, inLabel);
  783. !     if (status != SUCCESS) {
  784. !         printf("Unable to erase old label.\n");
  785. !     }
  786. !     }
  787. !     printf("Write this label to all valid partitions? (y/n) ");
  788. !     n = scanf("%s", answer);
  789. !     if ((n == EOF) || strcasecmp(answer, "y")) {
  790. !     printf("Writing disk label to %s.\n", toName);
  791. !     status = Disk_WriteLabel(toStreamID, diskLabelPtr, outLabel);
  792. !     return status;
  793. !     } else {
  794. !     int part, cyls, streamID, len, cantWriteToRawDisk = FALSE;
  795. !     char c, *devName;
  796.   
  797. !     len = strlen(toName);
  798. !     devName = (char *)malloc(sizeof(char) * len + 1);
  799. !         if (devName == NULL) {
  800. !         perror("allocating string");
  801. !         exit(FAILURE);
  802.       }
  803. !     c = toName[len - 1];
  804. !     if (c >= 'a' && c < 'i') {
  805. !         /*
  806. !          * the original destination name is a partition, 
  807. !          * e.g. "/dev/rsd00a", so make sure to write the label
  808. !          * to the beginning of the raw disk and then
  809. !          * write the label to all valid partitions
  810. !          */
  811. !         sprintf(devName, "%s",toName);
  812. !         devName[--len] = '\0';  
  813. !         streamID = open(devName, O_RDWR, 0);
  814. !     } else {
  815. !         /*
  816. !          * the original destination name is a raw disk,
  817. !          * e.g. "/dev/rsd00", so write the label to the raw
  818. !          * disk and then to all valid partitions
  819. !          */
  820. !         sprintf(devName, "%s",toName);
  821. !         streamID = toStreamID;
  822.       }
  823. !     printf("raw device: %s\n", devName);
  824. !     if (streamID >= 0) {
  825. !         status = Disk_WriteLabel(streamID, diskLabelPtr, outLabel);
  826. !         if (status != SUCCESS) {
  827. !         printf("Unable to write disk label to ");
  828. !         printf("%s...skipping\n", devName);
  829. !         cantWriteToRawDisk = TRUE;
  830. !         }
  831. !     } else {
  832. !         cantWriteToRawDisk = TRUE;
  833.       }
  834. !     devName[len + 1] = '\0';
  835. !     for (part = 0 ; part < diskLabelPtr -> numPartitions; part++) {
  836. !         cyls = diskLabelPtr->partitions[part].numCylinders;
  837. !         if (cyls <= 0) {
  838. !         continue;
  839. !         }
  840. !         devName[len] = 'a' + part;
  841. !         printf("partition: %s\n", devName);
  842. !         if (!strcmp(devName, fromName)) {
  843. !         streamID = fromStreamID;
  844. !         } else if (!strcmp(devName, toName)) {
  845. !         streamID = toStreamID;
  846. !         } else {
  847. !         streamID = open(devName, O_RDWR, 0);
  848. !         if (streamID < 0) {
  849. !             perror("Can't open device");
  850. !             exit(FAILURE);
  851. !         }
  852. !         }
  853. !         status = Disk_HasFilesystem(streamID, diskLabelPtr);
  854. !         if (status == DISK_HAS_NO_FS) {
  855. !         printf("Could not find file system on ");
  856. !         printf("%s...skipping\n", devName);
  857. !         continue;
  858. !         }
  859. !         status = Disk_WriteLabel(streamID, diskLabelPtr, outLabel);
  860. !         if (status) {
  861. !         printf("Unable to write disk label to ");
  862. !         printf("%s...skipping\n", devName);
  863. !         } else {
  864. !         /*
  865. !          * Having written to the partition, if the partition
  866. !          * starts at cylinder 0 then we have effectively
  867. !          * written to the raw disk
  868. !          */
  869. !         if (diskLabelPtr->partitions[part].firstCylinder == 0) {
  870. !             cantWriteToRawDisk = FALSE;
  871. !         }
  872. !         }
  873. !     }
  874. !     if (cantWriteToRawDisk == TRUE) {
  875. !         devName[len] = '\0';
  876. !         printf("Warning:  either couldn't open and write to");
  877. !         printf("%s or\ncouldn't write to a valid partition ", devName);
  878. !         printf("that starts at cylinder 0.\n");
  879. !     }
  880. !     }
  881. ! }
  882. ! 
  883. ! /*
  884. !  *----------------------------------------------------------------------
  885. !  *
  886. !  * EditLabel --
  887. !  *
  888. !  *    Interactively edits the disk label.
  889. !  *
  890. !  * Results:
  891. !  *    None.
  892. !  *
  893. !  * Side effects:
  894. !  *    Changes contents of the disk label.
  895. !  *
  896. !  *----------------------------------------------------------------------
  897. !  */
  898. ! static void
  899. ! EditLabel(streamID, labelPtr)
  900. !     int            streamID;    /* Handle on raw disk */
  901. !     Disk_Label        *labelPtr;    /* The disk label */
  902. ! {
  903. !     int                 numHeads, numSectors, part;
  904. !     ReturnStatus        status = SUCCESS;
  905. !     int                 first, cyls, last, lastSector, lastCyl;
  906. !     char            buffer[DEV_BYTES_PER_SECTOR];
  907. !     char        *tmpPtr;
  908. !     int            labelLen;
  909.   
  910.   editLabel:
  911. !     printf("Size of ascii label (%d): ", labelPtr->asciiLabelLen);
  912. !     InputNumber(&labelPtr->asciiLabelLen);
  913. !     printf("ascii label (%s): ", labelPtr->asciiLabel);
  914. !     tmpPtr = fgets(buffer, labelPtr->asciiLabelLen,stdin);
  915. !     if (tmpPtr == NULL) {
  916. !     exit(1);
  917. !     }
  918. !     printf("%d\n", strlen(buffer));
  919. !     if (strlen(buffer) > 1) {
  920. !     labelLen = Min(strlen(buffer), labelPtr->asciiLabelLen);
  921. !     strncpy(labelPtr->asciiLabel, buffer, labelLen);
  922. !     labelPtr->asciiLabel[labelLen - 1] = '\0';
  923. !     }
  924. !     printf("Number of heads (%d): ", labelPtr->numHeads);
  925. !     InputNumber(&labelPtr->numHeads);
  926. !     printf("Number of sectors per track (%d): ", labelPtr->numSectors);
  927. !     InputNumber(&labelPtr->numSectors);
  928. !     printf("Number of cylinders (%d): ", labelPtr->numCylinders);
  929. !     InputNumber(&labelPtr->numCylinders);
  930. !     printf("Number of alternate cylinders (%d): ", labelPtr->numAltCylinders);
  931. !     InputNumber(&labelPtr->numAltCylinders);
  932. !     printf("Starting sector of summary info (%d): ", labelPtr->summarySector);
  933. !     InputNumber(&labelPtr->summarySector);
  934. !     printf("Starting sector of boot program (%d): ", labelPtr->bootSector);
  935. !     InputNumber(&labelPtr->bootSector);
  936. !     printf("Number of boot sectors (%d): ", labelPtr->numBootSectors);
  937. !     InputNumber(&labelPtr->numBootSectors);
  938. !     printf("Starting sector of domain header (%d): ", labelPtr->domainSector);
  939. !     InputNumber(&labelPtr->domainSector);
  940. !     numHeads = labelPtr->numHeads;
  941. !     numSectors = labelPtr->numSectors;
  942.       if (numHeads * numSectors != 
  943. !     labelPtr->numHeads * labelPtr->numSectors) {
  944.       printf(
  945.       "The size of a cylinder changed so I have to zero the partition map.\n");
  946. !     for (part=0 ; part < labelPtr->numPartitions; part++) {
  947. !         labelPtr->partitions[part].firstCylinder = 0;
  948. !         labelPtr->partitions[part].numCylinders = 0;
  949.       }
  950.       }
  951. !     for (part=0 ; part < labelPtr->numPartitions; part++) {
  952. !     first = labelPtr->partitions[part].firstCylinder;
  953. !     cyls = labelPtr->partitions[part].numCylinders;
  954.       last = (cyls > 0) ? (cyls + first - 1) : first;
  955. !     printf("\n%c: First %4d Last %4d Num %4d (%7d sectors)\n",
  956.           'a' + part, first, last, cyls,
  957. !         cyls *  labelPtr->numHeads * labelPtr->numSectors);
  958. !     printf("First (%d): ", labelPtr->partitions[part].firstCylinder);
  959. !     InputNumber(&labelPtr->partitions[part].firstCylinder);
  960. !     printf("Num (%d): ", labelPtr->partitions[part].numCylinders);
  961. !     InputNumber(&labelPtr->partitions[part].numCylinders);
  962.       }
  963. +     lastCyl = 0;
  964. +     printf("\nNew Label\n");
  965. +     Disk_PrintLabel(labelPtr);
  966.       lastSector = (lastCyl + 1) * numHeads * numSectors - 1;
  967.       status = Disk_SectorRead(streamID, lastSector, 1, buffer);
  968.       if (status != 0) {
  969.       printf("I couldn't read the last sector (sector %d)!!!\n", lastSector);
  970. +     printf("Either the disk isn't as big as you think it is,\n");
  971. +     printf("or the device is not a raw device.\n");
  972. +     printf("(cylinders=%d, numHeads=%d, numSectors=%d)\n", lastCyl+1,
  973. +         numHeads, numSectors);
  974. +     printf("Status = %x\n", status);
  975.       }
  976.       printf("\nCommit new label? (y/n) ");
  977. !     if (!IsYes()) {
  978.       printf("Try again\n");
  979.       goto editLabel;
  980.       }
  981. ***************
  982. *** 616,1034 ****
  983.   /*
  984.    *----------------------------------------------------------------------
  985.    *
  986. !  * ConvertSunToSprite --
  987. !  *
  988. !  *    Converts a Sun label to a Sprite label. Any fields that cannot
  989. !  *    be converted directly are set to their default values.
  990. !  *    diskInfoPtr is used to get the name and the sector locations. 
  991. !  *
  992. !  * Results:
  993. !  *    None.
  994. !  *
  995. !  * Side effects:
  996. !  *    None.
  997. !  *
  998. !  *----------------------------------------------------------------------
  999. !  */
  1000. ! 
  1001. ! void
  1002. ! ConvertSunToSprite(diskInfoPtr, sunLabelPtr, diskHeaderPtr)
  1003. !     Disk_Info            *diskInfoPtr;
  1004. !     Sun_DiskLabel        *sunLabelPtr;
  1005. !     Fsdm_DiskHeader        *diskHeaderPtr;
  1006. ! {
  1007. !     int i;
  1008. ! 
  1009. !     /*
  1010. !      * Verify the magic number and the checksum.
  1011. !      */
  1012. !     if (sunLabelPtr->magic != SUN_DISK_MAGIC) {
  1013. !     printf("Bad magic number on disk <%x> not <%x>\n",
  1014. !         sunLabelPtr->magic, SUN_DISK_MAGIC);
  1015. !     }
  1016. !     if (!CheckSunCheckSum(sunLabelPtr)) {
  1017. !     printf("Check sum incorrect, 0x%x not 0x%x\n",
  1018. !         SeeSunCheckSum(sunLabelPtr), sunLabelPtr->checkSum);
  1019. !     }
  1020. !     bzero(diskHeaderPtr, sizeof(*diskHeaderPtr));
  1021. !     diskHeaderPtr->magic = FSDM_DISK_MAGIC;
  1022. !     diskHeaderPtr->partition = 0;
  1023. !     diskHeaderPtr->bootSector = diskInfoPtr->bootSector;
  1024. !     diskHeaderPtr->numBootSectors = diskInfoPtr->numBootSectors;
  1025. !     diskHeaderPtr->summarySector = diskInfoPtr->summarySector;
  1026. !     diskHeaderPtr->domainSector = diskInfoPtr->domainSector;
  1027. !     diskHeaderPtr->numDomainSectors = diskInfoPtr->numDomainSectors;
  1028. !     diskHeaderPtr->numSectors = sunLabelPtr->numSectors;
  1029. !     diskHeaderPtr->numHeads = sunLabelPtr->numHeads;
  1030. !     diskHeaderPtr->numCylinders = sunLabelPtr->numCylinders;
  1031. !     diskHeaderPtr->numAltCylinders = sunLabelPtr->numAltCylinders;
  1032. !     strncpy(diskHeaderPtr->asciiLabel, diskInfoPtr->asciiLabel, 128);
  1033. !     for (i = 0; i < FSDM_NUM_DISK_PARTS && i < SUN_NUM_DISK_PARTS; i++) {
  1034. !     diskHeaderPtr->map[i].firstCylinder = sunLabelPtr->map[i].cylinder;
  1035. !     diskHeaderPtr->map[i].numCylinders = sunLabelPtr->map[i].numBlocks /
  1036. !         (diskInfoPtr->numHeads * diskInfoPtr->numSectors);
  1037. !     }
  1038. !     MakeSpriteCheckSum(diskHeaderPtr);
  1039. ! }
  1040. ! 
  1041. ! /*
  1042. !  *----------------------------------------------------------------------
  1043. !  *
  1044. !  * ConvertSpriteToSun --
  1045. !  *
  1046. !  *    Converts a Sprite label to a Sun label. Any fields that cannot
  1047. !  *    be converted directly are set to their default values.
  1048. !  *
  1049. !  * Results:
  1050. !  *    None.
  1051. !  *
  1052. !  * Side effects:
  1053. !  *    None.
  1054. !  *
  1055. !  *----------------------------------------------------------------------
  1056. !  */
  1057. ! 
  1058. ! void
  1059. ! ConvertSpriteToSun(diskInfoPtr, diskHeaderPtr, sunLabelPtr)
  1060. !     Disk_Info            *diskInfoPtr;
  1061. !     Fsdm_DiskHeader        *diskHeaderPtr;
  1062. !     Sun_DiskLabel        *sunLabelPtr;
  1063. ! {
  1064. !     int i;
  1065. ! 
  1066. !     /*
  1067. !      * Verify the magic number and the checksum.
  1068. !      */
  1069. !     if (diskHeaderPtr->magic != FSDM_DISK_MAGIC) {
  1070. !     printf("Bad magic number on disk <%x> not <%x>\n",
  1071. !         diskHeaderPtr->magic, FSDM_DISK_MAGIC);
  1072. !     }
  1073. !     if (!CheckSpriteCheckSum(diskHeaderPtr)) {
  1074. !     printf("Check sum incorrect, 0x%x not 0x%x\n",
  1075. !         SeeSpriteCheckSum(diskHeaderPtr), diskHeaderPtr->checkSum);
  1076. !     }
  1077. !     bzero(sunLabelPtr, sizeof(*sunLabelPtr));
  1078. !     sunLabelPtr->magic = SUN_DISK_MAGIC;
  1079. !     sunLabelPtr->numSectors = diskHeaderPtr->numSectors;
  1080. !     sunLabelPtr->numHeads = diskHeaderPtr->numHeads;
  1081. !     sunLabelPtr->numCylinders = diskHeaderPtr->numCylinders;
  1082. !     sunLabelPtr->numAltCylinders = diskHeaderPtr->numAltCylinders;
  1083. !     sunLabelPtr->partitionID = 0;
  1084. !     sunLabelPtr->bhead = 0;
  1085. !     sunLabelPtr->gap1 = 65535;
  1086. !     sunLabelPtr->gap2 = 65535;
  1087. !     sunLabelPtr->interleave = 1;
  1088. !     strncpy(sunLabelPtr->asciiLabel, diskInfoPtr->asciiLabel, 128);
  1089. !     for (i = 0; i < FSDM_NUM_DISK_PARTS && i < SUN_NUM_DISK_PARTS; i++) {
  1090. !     sunLabelPtr->map[i].cylinder = diskHeaderPtr->map[i].firstCylinder;
  1091. !     sunLabelPtr->map[i].numBlocks = diskHeaderPtr->map[i].numCylinders *
  1092. !         diskInfoPtr->numHeads * diskInfoPtr->numSectors;
  1093. !     }
  1094. !     MakeSunCheckSum(sunLabelPtr);
  1095. ! }
  1096. ! 
  1097. ! /*
  1098. !  *----------------------------------------------------------------------
  1099. !  *
  1100. !  * ConvertDecToSprite --
  1101. !  *
  1102. !  *    Converts a Dec label to a Sprite label. Any fields that cannot
  1103. !  *    be converted directly are set to their default values.
  1104. !  *
  1105. !  * Results:
  1106. !  *    None.
  1107. !  *
  1108. !  * Side effects:
  1109. !  *    None.
  1110. !  *
  1111. !  *----------------------------------------------------------------------
  1112. !  */
  1113. ! 
  1114. ! void
  1115. ! ConvertDecToSprite(diskInfoPtr, decLabelPtr, diskHeaderPtr)
  1116. !     Disk_Info            *diskInfoPtr;
  1117. !     Dec_DiskLabel        *decLabelPtr;
  1118. !     Fsdm_DiskHeader        *diskHeaderPtr;
  1119. ! {
  1120. !     int i;
  1121. !     int cylLength = diskInfoPtr->numHeads * diskInfoPtr->numSectors *
  1122. !         DEV_BYTES_PER_SECTOR;
  1123. !     int totalCyls = 0;
  1124. ! 
  1125. !     /*
  1126. !      * Verify the magic number and the checksum.
  1127. !      */
  1128. !     if (decLabelPtr->magic != DEC_LABEL_MAGIC) {
  1129. !     printf("Bad magic number on disk <%x> not <%x>\n",
  1130. !         decLabelPtr->magic, DEC_LABEL_MAGIC);
  1131. !     } else if (decLabelPtr->spriteMagic != FSDM_DISK_MAGIC) {
  1132. !     printf("Disk has original dec label, not Sprite/dec label\n");
  1133. !     }
  1134. !     bzero(diskHeaderPtr, sizeof(*diskHeaderPtr));
  1135. !     diskHeaderPtr->magic = FSDM_DISK_MAGIC;
  1136. !     diskHeaderPtr->partition = 0;
  1137. !     diskHeaderPtr->bootSector = diskInfoPtr->bootSector;
  1138. !     diskHeaderPtr->numBootSectors = diskInfoPtr->numBootSectors;
  1139. !     diskHeaderPtr->summarySector = diskInfoPtr->summarySector;
  1140. !     diskHeaderPtr->domainSector = diskInfoPtr->domainSector;
  1141. !     diskHeaderPtr->numDomainSectors = diskInfoPtr->numDomainSectors;
  1142. !     diskHeaderPtr->numSectors = decLabelPtr->numSectors;
  1143. !     diskHeaderPtr->numHeads = decLabelPtr->numHeads;
  1144. !     diskHeaderPtr->numAltCylinders = decLabelPtr->numAltCylinders;
  1145. !     *diskHeaderPtr->asciiLabel = '\0';
  1146. !     for (i = 0; i < FSDM_NUM_DISK_PARTS && i < DEC_NUM_DISK_PARTS; i++) {
  1147. !     if (decLabelPtr->map[i].offsetBytes % cylLength != 0) {
  1148. !         printf("Warning: offset %x is not multiple of cylinder size\n",
  1149. !             decLabelPtr->map[i].offsetBytes);
  1150. !     }
  1151. !     diskHeaderPtr->map[i].firstCylinder = decLabelPtr->map[i].numBytes/
  1152. !         cylLength;
  1153. !     if (decLabelPtr->map[i].numBytes % cylLength != 0) {
  1154. !         printf("Warning: partition %x is not multiple of cylinder size\n",
  1155. !             decLabelPtr->map[i].offsetBytes);
  1156. !     }
  1157. !     diskHeaderPtr->map[i].numCylinders = decLabelPtr->map[i].numBytes /
  1158. !         cylLength;
  1159. !     totalCyls += diskHeaderPtr->map[i].numCylinders;
  1160. !     }
  1161. !     diskHeaderPtr->numCylinders = totalCyls;
  1162. !     MakeSpriteCheckSum(diskHeaderPtr);
  1163. ! }
  1164. ! 
  1165. ! /*
  1166. !  *----------------------------------------------------------------------
  1167. !  *
  1168. !  * ConvertSpriteToDec --
  1169.    *
  1170. !  *    Converts a Sprite label to a Dec label. Any fields that cannot
  1171. !  *    be converted directly are set to their default values.
  1172.    *
  1173.    * Results:
  1174.    *    None.
  1175.    *
  1176.    * Side effects:
  1177. !  *    None.
  1178.    *
  1179.    *----------------------------------------------------------------------
  1180.    */
  1181. ! 
  1182. ! void
  1183. ! ConvertSpriteToDec(diskInfoPtr, diskHeaderPtr, decLabelPtr)
  1184. !     Disk_Info            *diskInfoPtr;
  1185. !     Fsdm_DiskHeader        *diskHeaderPtr;
  1186. !     Dec_DiskLabel        *decLabelPtr;
  1187.   {
  1188. !     int i;
  1189. !     int cylLength = diskInfoPtr->numHeads * diskInfoPtr->numSectors *
  1190. !         DEV_BYTES_PER_SECTOR;
  1191. ! 
  1192. !     /*
  1193. !      * Verify the magic number and the checksum.
  1194. !      */
  1195. !     if (diskHeaderPtr->magic != FSDM_DISK_MAGIC) {
  1196. !     printf("Bad magic number on disk <%x> not <%x>\n",
  1197. !         diskHeaderPtr->magic, FSDM_DISK_MAGIC);
  1198. !     }
  1199. !     bzero(decLabelPtr, sizeof(*decLabelPtr));
  1200. !     decLabelPtr->magic = DEC_LABEL_MAGIC;
  1201. !     decLabelPtr->isPartitioned = 1;
  1202. !     decLabelPtr->numHeads = diskHeaderPtr->numHeads;
  1203. !     decLabelPtr->numSectors = diskHeaderPtr->numSectors;
  1204. !     decLabelPtr->domainSector = diskHeaderPtr->domainSector;
  1205. !     decLabelPtr->numDomainSectors = diskHeaderPtr->numDomainSectors;
  1206. !     decLabelPtr->numCylinders = diskHeaderPtr->numCylinders;
  1207. !     decLabelPtr->numAltCylinders = diskHeaderPtr->numAltCylinders;
  1208. !     decLabelPtr->bootSector = DEC_BOOT_SECTOR;
  1209. !     decLabelPtr->numBootSectors = diskHeaderPtr->numBootSectors;
  1210. !     decLabelPtr->summarySector = diskHeaderPtr->summarySector;
  1211. !     decLabelPtr->domainSector = diskHeaderPtr->domainSector;
  1212. !     decLabelPtr->numDomainSectors = diskHeaderPtr->numDomainSectors;
  1213. !     decLabelPtr->spriteMagic = FSDM_DISK_MAGIC;
  1214. !     strncpy(decLabelPtr->asciiLabel, diskInfoPtr->asciiLabel, 128);
  1215. !     for (i = 0; i < FSDM_NUM_DISK_PARTS && i < DEC_NUM_DISK_PARTS; i++) {
  1216. !     decLabelPtr->map[i].numBytes = diskHeaderPtr->map[i].numCylinders *
  1217. !             cylLength;
  1218. !     decLabelPtr->map[i].offsetBytes = diskHeaderPtr->map[i].firstCylinder *
  1219. !         cylLength;
  1220. !     }
  1221. ! }
  1222. ! 
  1223. ! 
  1224. ! /*
  1225. !  *----------------------------------------------------------------------
  1226. !  *
  1227. !  * DoDecLabel --
  1228. !  *
  1229. !  *    Sets up a Dec label.
  1230. !  *
  1231. !  * Results:
  1232. !  *    None.
  1233. !  *
  1234. !  * Side effects:
  1235. !  *    None.
  1236. !  *
  1237. !  *----------------------------------------------------------------------
  1238. !  */
  1239.   
  1240. ! ReturnStatus
  1241. ! DoDecLabel(diskInfoPtr, streamID, decLabelPtr)
  1242. !     Disk_Info            *diskInfoPtr;
  1243. !     int                streamID;
  1244. !     Dec_DiskLabel         *decLabelPtr;
  1245. ! {
  1246. !     int             part;
  1247. !     ReturnStatus         status = SUCCESS;
  1248. !     int                cyls;
  1249. !     int                first;
  1250. !     int                last;
  1251. !     int                cylLength;
  1252. !     Fsdm_DiskPartition        partitionMap[DEC_NUM_DISK_PARTS];
  1253. ! 
  1254. !     printInfo("DEC", diskInfoPtr);
  1255. ! 
  1256. !     /*
  1257. !      * Verify the magic number and the checksum.
  1258. !      */
  1259. !     if (decLabelPtr->magic != DEC_LABEL_MAGIC) {
  1260. !     printf("Bad magic number on disk <%x> not <%x>\n",
  1261. !         decLabelPtr->magic, DEC_LABEL_MAGIC);
  1262. !     }
  1263. !     cylLength = decLabelPtr->numHeads * decLabelPtr->numSectors *
  1264. !         DEV_BYTES_PER_SECTOR;
  1265. !     for (part=0 ; part < DEC_NUM_DISK_PARTS; part++) {
  1266. !     first = decLabelPtr->map[part].offsetBytes / cylLength;;
  1267. !     cyls = decLabelPtr->map[part].numBytes / cylLength;
  1268. !     last = (cyls > 0) ? (cyls + first - 1) : first;
  1269. !     printf("%c: First %4d Last %4d Num %4d (Bytes %7d)\n",
  1270. !         'a' + part, first, last, cyls,
  1271. !         decLabelPtr->map[part].numBytes);
  1272. !     partitionMap[part].firstCylinder = first;
  1273. !     partitionMap[part].numCylinders = cyls;
  1274. !     }
  1275. !     if (!writeLabel) {
  1276. !     return(SUCCESS);
  1277. !     }
  1278. !     DoNewLabel(diskInfoPtr,partitionMap,DEC_NUM_DISK_PARTS, streamID);
  1279. !     decLabelPtr->numHeads = diskInfoPtr->numHeads;
  1280. !     decLabelPtr->numSectors = diskInfoPtr->numSectors;
  1281. !     decLabelPtr->summarySector = diskInfoPtr->summarySector;
  1282. !     decLabelPtr->bootSector = diskInfoPtr->bootSector;
  1283. !     decLabelPtr->numBootSectors = diskInfoPtr->numBootSectors;
  1284. !     decLabelPtr->domainSector = diskInfoPtr->domainSector;
  1285. !     decLabelPtr->version = DEC_LABEL_VERSION;
  1286. !     decLabelPtr->magic = DEC_LABEL_MAGIC;
  1287. !     decLabelPtr->spriteMagic = FSDM_DISK_MAGIC;
  1288. !     strcpy(decLabelPtr->asciiLabel, diskInfoPtr->asciiLabel);
  1289. !     cylLength = decLabelPtr->numHeads * decLabelPtr->numSectors *
  1290. !         DEV_BYTES_PER_SECTOR;
  1291. !     for (part=0 ; part < DEC_NUM_DISK_PARTS; part++) {
  1292. !     decLabelPtr->map[part].offsetBytes = partitionMap[part].firstCylinder *
  1293. !         cylLength;
  1294. !     decLabelPtr->map[part].numBytes = partitionMap[part].numCylinders *
  1295. !         cylLength;
  1296.       }
  1297. !     printf("Writing new dec label\n");
  1298. !     status = Disk_SectorWrite(streamID, DEC_LABEL_SECTOR, 1, decLabelPtr);
  1299. !     return status;
  1300. ! }
  1301. ! 
  1302. ! /*
  1303. !  *----------------------------------------------------------------------
  1304. !  *
  1305. !  * EraseOldLabel --
  1306. !  *
  1307. !  *    Zero out the block containing the old label.
  1308. !  *
  1309. !  * Results:
  1310. !  *    Status.
  1311. !  *
  1312. !  * Side effects:
  1313. !  *    None.
  1314. !  *
  1315. !  *----------------------------------------------------------------------
  1316. !  */
  1317. ! 
  1318. ! ReturnStatus
  1319. ! EraseOldLabel(streamID, sector)
  1320. ! int streamID;
  1321. ! int sector;
  1322. ! {
  1323. !     char buffer[DEV_BYTES_PER_SECTOR];
  1324. !     bzero(buffer, DEV_BYTES_PER_SECTOR);
  1325. !     printf("Erasing label at sector %d\n",sector);
  1326. !     return Disk_SectorWrite(streamID, sector, 1, buffer);
  1327. ! }
  1328. ! 
  1329. ! /*
  1330. !  *----------------------------------------------------------------------
  1331. !  *
  1332. !  * printInfo --
  1333. !  *
  1334. !  *    Print out info in the diskInfoPtr;
  1335. !  *
  1336. !  * Results:
  1337. !  *    None.
  1338. !  *
  1339. !  * Side effects:
  1340. !  *    None.
  1341. !  *
  1342. !  *----------------------------------------------------------------------
  1343. !  */
  1344. ! printInfo(type, diskInfoPtr)
  1345. ! char                *type;
  1346. ! Disk_Info            *diskInfoPtr;
  1347. ! {
  1348. !     printf("%s LABEL <%s>\n", type, diskInfoPtr->asciiLabel);
  1349. !     printf(" %d heads %d sectors/track\n",
  1350. !     diskInfoPtr->numHeads, diskInfoPtr->numSectors);
  1351. !     printf("Boot sector = %x\n", diskInfoPtr->bootSector);
  1352. !     printf("Number of boot sectors = %x\n", diskInfoPtr->numBootSectors);
  1353. !     printf("Summary sector = %x\n", diskInfoPtr->summarySector);
  1354. !     printf("Domain sector = %x\n", diskInfoPtr->domainSector);
  1355. !     printf("Number of domain sectors = %x\n", diskInfoPtr->numDomainSectors);
  1356. ! }
  1357. ! 
  1358. ! /*
  1359. !  *----------------------------------------------------------------------
  1360. !  *
  1361. !  * getNum --
  1362. !  *
  1363. !  *    Get a number interactively.
  1364. !  *
  1365. !  * Results:
  1366. !  *    Number.
  1367. !  *
  1368. !  * Side effects:
  1369. !  *    None.
  1370. !  *
  1371. !  *----------------------------------------------------------------------
  1372. !  */
  1373. ! int
  1374. ! getNum(string)
  1375. ! char    *string;
  1376. ! {
  1377. !     int n, val;
  1378. !     char answer[80];
  1379. !     do {
  1380. !     printf("%s ",string);
  1381. !     n = scanf("%d", &val);
  1382. !     if (n == EOF) {
  1383. !         exit(1);
  1384. !     }
  1385. !     if (n == 0) {
  1386. !         /*
  1387. !          * Skip the trashy line
  1388. !          */
  1389. !         fgets(answer, sizeof(answer), stdin);
  1390. !     }
  1391. !     } while (n<1);
  1392. !     return val;
  1393. ! }
  1394. ! 
  1395.   /*
  1396.    *----------------------------------------------------------------------
  1397.    *
  1398. !  * isYes --
  1399.    *
  1400.    *    Returns TRUE if user answers y.
  1401.    *
  1402. --- 421,459 ----
  1403.   /*
  1404.    *----------------------------------------------------------------------
  1405.    *
  1406. !  * InputNumber --
  1407.    *
  1408. !  *    Get a number interactively.
  1409.    *
  1410.    * Results:
  1411.    *    None.
  1412.    *
  1413.    * Side effects:
  1414. !  *    Stuff is read from stdin..
  1415.    *
  1416.    *----------------------------------------------------------------------
  1417.    */
  1418. ! static void
  1419. ! InputNumber(number)
  1420. !     int        *number;    /* Place to store number. */
  1421.   {
  1422. !     int n, val;
  1423. !     char buffer[80];
  1424.   
  1425. !     if (fgets(buffer, 80, stdin) == NULL) {
  1426. !     exit(1);
  1427.       }
  1428. !     n = sscanf(buffer, "%d", &val);
  1429. !     if (n < 1) {
  1430. !     return;
  1431. !     }
  1432. !     *number = val;
  1433. ! }
  1434. ! 
  1435.   /*
  1436.    *----------------------------------------------------------------------
  1437.    *
  1438. !  * IsYes --
  1439.    *
  1440.    *    Returns TRUE if user answers y.
  1441.    *
  1442. ***************
  1443. *** 1040,1049 ****
  1444.    *
  1445.    *----------------------------------------------------------------------
  1446.    */
  1447. ! int
  1448. ! isYes()
  1449.   {
  1450. !     int n, val;
  1451.       char answer[80];
  1452.       n = scanf("%s", answer);
  1453.       if (n == EOF) {
  1454. --- 465,474 ----
  1455.    *
  1456.    *----------------------------------------------------------------------
  1457.    */
  1458. ! static int
  1459. ! IsYes()
  1460.   {
  1461. !     int n;
  1462.       char answer[80];
  1463.       n = scanf("%s", answer);
  1464.       if (n == EOF) {
  1465.